import api from './config'
import { getBaseURL } from '../config/api-config'
import API_CONFIG from './apiConfig.js'
import logger from '../utils/logger.js'

/**
 * 题目相关API
 */

/**
 * 创建新的测试题目
 * @param {Object} questionData - 题目数据
 * @param {number} questionData.createUserId - 创建用户ID
 * @param {number} questionData.courseLevelId - 课程等级ID
 * @param {string} questionData.questionName - 题目名称
 * @param {number} questionData.questionType - 题目类型
 * @param {number} questionData.isPublic - 是否公开 (1:公开, 0:私有)
 * @param {number} questionData.timeLimit - 时间限制(毫秒)
 * @param {number} questionData.spaceLimitation - 空间限制(字节)
 * @param {string} questionData.questionDescribe - 题目描述
 * @param {string} questionData.questionPicture - 题目图片URL
 * @param {string} questionData.inputFormat - 输入格式
 * @param {string} questionData.outputFormat - 输出格式
 * @param {string} questionData.rangeAndPrompt - 数据范围和提示
 * @param {number} questionData.difficulty - 难度等级
 * @param {string} questionData.label - 标签
 * @param {number} questionData.submissionQuantity - 提交数量
 * @param {number} questionData.byQuantity - 通过数量
 * @returns {Promise} API响应
 */
export const createTestQuestion = async (questionData) => {
  logger.log('🚀 [API] 创建新测试题目...')
  logger.log('📝 [API] 题目数据:', questionData)
  logger.log('📊 [API] 请求方法: POST')
  logger.log('📦 [API] 请求体内容:')
  console.table(questionData)
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/testQuestion/add'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/testQuestion/add`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 🔥 统一使用 FormData 格式发送（后端对此格式处理更可靠）
    logger.log('📦 [API] 使用 FormData 格式发送')
    
    let requestBody
    let headers = {
      'Authorization': token || ''
    }
    
    const formData = new FormData()
    
    // 添加所有字段到 FormData（跳过 null、undefined 和空字符串）
    Object.keys(questionData).forEach(key => {
      const value = questionData[key]
      // 跳过 null、undefined 和空字符串（但保留数字0和布尔false）
      if (value === null || value === undefined || value === '') {
        logger.log(`🗑️ [API] 跳过空字段: ${key} = ${value}`)
        return
      }
      
      if (key === 'pictureFile' && value instanceof File) {
        // 参考程序结果图片文件
        formData.append('pictureFile', value)
        logger.log(`📎 [API] 添加文件字段: pictureFile = ${value.name}`)
      } else if (key === 'outputFile' && value instanceof File) {
        // 输出格式图片文件
        formData.append('outputFile', value)
        logger.log(`📎 [API] 添加文件字段: outputFile = ${value.name}`)
      } else if (key !== 'pictureFile' && key !== 'outputFile') {
        // 普通字段（跳过已处理的文件字段）
        formData.append(key, String(value))
        logger.log(`📝 [API] 添加字段: ${key} = ${value}`)
      }
    })
    
    requestBody = formData
    // FormData 会自动设置 Content-Type，包含正确的 boundary
    // 所以不要手动设置 Content-Type
    logger.log('✅ [API] FormData 准备完成')
    
    // 使用fetch调用代理路径
    const response = await fetch(proxyApiUrl, {
      method: 'POST',
      headers: headers,
      body: requestBody
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    logger.log('✅ [API] 测试题目创建成功')
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 创建测试题目失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack
    })
    throw error
  }
}

/**
 * 获取用户创建的题目列表（用于刷新功能）
 * @param {Object} params - 查询参数
 * @param {number} params.current - 当前页码（可选，默认1）
 * @param {number} params.size - 每页大小（可选，默认10）
 * @param {string} params.keyword - 关键词搜索（可选）
 * @param {number} params.difficulty - 难度筛选（可选）
 * @param {number} params.questionType - 题目类型筛选（可选）
 * @returns {Promise} API响应
 */
// 获取当前用户ID的辅助方法（保持字符串格式避免精度丢失）
const getCurrentUserIdFromToken = () => {
  try {
    const token = localStorage.getItem('token')
    if (token) {
      const tokenParts = token.split('.')
      if (tokenParts.length === 3) {
        // 关键修复：直接解析base64字符串，避免JSON.parse的数字精度丢失
        const payloadBase64 = tokenParts[1]
        const payloadStr = atob(payloadBase64)
        logger.log('🔍 [API] JWT payload字符串:', payloadStr)
        
        // 使用正则表达式提取ID，保持字符串格式
        const idMatch = payloadStr.match(/"id":(\d+)/)
        if (idMatch && idMatch[1]) {
          const userId = idMatch[1] // 保持字符串格式
          logger.log('👤 [API] 从JWT令牌获取用户ID (字符串格式):', userId)
          logger.log('👤 [API] 用户ID长度:', userId.length, '位')
          return userId
        }
        
        // 备用方案：如果正则匹配失败，使用JSON.parse但立即转为字符串
        const payload = JSON.parse(payloadStr)
        const userIdNum = payload.claims?.id
        if (userIdNum) {
          const userId = String(userIdNum)
          logger.warn('⚠️ [API] 使用备用方案获取用户ID，可能有精度丢失:', userId)
          return userId
        }
      }
    }
    
    // 备选方案：从localStorage获取用户信息
    const userInfoStr = localStorage.getItem('userInfo')
    if (userInfoStr) {
      const userInfo = JSON.parse(userInfoStr)
      const userId = String(userInfo.id || '')
      if (userId && userId !== '') {
        logger.log('👤 [API] 从localStorage获取用户ID:', userId)
        return userId
      }
    }
  } catch (error) {
    logger.error('❌ [API] 获取用户ID失败:', error)
  }
  
  logger.warn('⚠️ [API] 无法获取用户ID')
  return null
}

export const getUserCreatedQuestions = async (params = {}) => {
  logger.log('🔄 [API] 获取用户创建的题目列表...')
  logger.log('📝 [API] 查询参数:', params)
  logger.log('📊 [API] 请求方法: GET')
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/testQuestion/list'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/testQuestion/list`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 获取当前用户ID，确保只获取用户自己创建的题目
    const currentUserId = getCurrentUserIdFromToken()
    logger.log('👤 [API] 当前用户ID:', currentUserId)
    
    // 构建查询参数
    const queryParams = new URLSearchParams()
    if (params.current) queryParams.append('current', params.current)
    if (params.size) queryParams.append('size', params.size)
    if (params.keyword) queryParams.append('keyword', params.keyword)
    if (params.difficulty) queryParams.append('difficulty', params.difficulty)
    if (params.questionType) queryParams.append('questionType', params.questionType)
    
    // 关键：添加创建用户ID筛选，确保只获取当前用户创建的题目
    // 尝试多种可能的参数名
    if (currentUserId) {
      queryParams.append('createUserId', currentUserId)
      queryParams.append('userId', currentUserId)  // 备选参数名
      queryParams.append('creatorId', currentUserId)  // 备选参数名
      logger.log('🔍 [API] 添加用户筛选条件:')
      logger.log('  - createUserId:', currentUserId)
      logger.log('  - userId:', currentUserId)
      logger.log('  - creatorId:', currentUserId)
    } else {
      logger.warn('⚠️ [API] 无法获取当前用户ID，可能会返回所有题目')
    }
    
    const finalUrl = queryParams.toString() ? `${proxyApiUrl}?${queryParams.toString()}` : proxyApiUrl
    logger.log('🔗 [API] 最终请求URL:', finalUrl)
    
    // 使用fetch调用代理路径
    const response = await fetch(finalUrl, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': token || ''
      }
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    logger.log('✅ [API] 用户创建题目列表获取成功')
    logger.log('📊 [API] 返回题目数量:', responseData.data?.records?.length || 0)
    logger.log('📊 [API] 总题目数:', responseData.data?.total || 0)
    
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 获取用户创建题目列表失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack
    })
    throw error
  }
}

/**
 * 获取题目列表
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码（必填）
 * @param {string} params.keyword - 关键词（可选）
 * @param {number} params.type - 题目类型（可选）
 * @param {number} params.difficulty - 难度等级（可选）
 * @param {number} params.isPublic - 是否公开（可选）
 * @param {string} params.label - 标签（可选）
 * @returns {Promise} API响应
 */
export const getTestQuestionList = async (params) => {
  logger.log('🔍 [API] 获取题目列表，参数:', params)
  
  try {
    const response = await api.get('/goc/testQuestion/list', {
      params,
      timeout: 15000
    })
    
    logger.log('✅ [API] 题目列表获取成功:', response)
    return response
  } catch (error) {
    logger.error('❌ [API] 题目列表获取失败:', error)
    throw error
  }
}

/**
 * 根据ID获取题目详情
 * @param {string|number} id - 题目ID
 * @returns {Promise} API响应
 */
export const getTestQuestionById = async (id) => {
  logger.log('🔍 [API] 获取题目详情，ID:', id)
  logger.log('📊 [API] 请求方法: GET')
  
  if (!id) {
    throw new Error('题目ID不能为空')
  }
  
  try {
    logger.log('🌐 [API] 接口地址: /goc/testQuestion/findById')
    logger.log('🌐 [API] 实际目标地址:', API_CONFIG.getFullURL('/goc/testQuestion/findById'))
    
    // 使用axios api实例调用，会自动添加JWT令牌
    const response = await api.get('/goc/testQuestion/findById', {
      params: {
        id: id  // 题目ID
      }
    })
    
    logger.log('✅ [API] 题目详情获取成功:', response)
    logger.log('🔍 [API] 后端返回的完整数据:', response.data)
    logger.log('🔍 [API] response.data.isRegular:', response.data?.isRegular)
    logger.log('🔍 [API] isRegular类型:', typeof response.data?.isRegular)
    return response
    
  } catch (error) {
    logger.error('❌ [API] 题目详情获取失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack,
      id,
      url: '/goc/testQuestion/findById'
    })
    throw error
  }
}

/**
 * 更新测试题目
 * @param {Object} questionData - 完整的题目数据
 * @param {number} questionData.id - 题目ID
 * @param {number} questionData.createUserId - 创建用户ID
 * @param {number} questionData.courseLevelId - 课程等级ID
 * @param {string} questionData.questionName - 题目名称
 * @param {number} questionData.questionType - 题目类型
 * @param {number} questionData.isPublic - 是否公开 (1:公开, 0:私有)
 * @param {number} questionData.timeLimit - 时间限制(毫秒)
 * @param {number} questionData.spaceLimitation - 空间限制(字节)
 * @param {string} questionData.questionDescribe - 题目描述
 * @param {string} questionData.questionPicture - 题目图片URL
 * @param {string} questionData.inputFormat - 输入格式
 * @param {string} questionData.outputFormat - 输出格式
 * @param {string} questionData.rangeAndPrompt - 数据范围和提示
 * @param {number} questionData.difficulty - 难度等级
 * @param {string} questionData.label - 标签
 * @param {number} questionData.submissionQuantity - 提交数量
 * @param {number} questionData.byQuantity - 通过数量
 * @returns {Promise} API响应
 */
export const updateTestQuestion = async (questionData) => {
  logger.log('🔄 [API] 更新测试题目...')
  logger.log('📝 [API] 题目数据:', questionData)
  logger.log('📊 [API] 请求方法: POST')
  logger.log('📦 [API] 请求体内容:')
  console.table(questionData)
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/testQuestion/update'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/testQuestion/update`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 检查是否包含文件（参考程序结果图片或输出格式图片）
    const hasPictureFile = questionData.pictureFile instanceof File
    const hasOutputFile = questionData.outputFile instanceof File
    const hasFile = hasPictureFile || hasOutputFile
    logger.log('🖼️ [API] 是否包含参考程序图片文件:', hasPictureFile)
    logger.log('🖼️ [API] 是否包含输出格式图片文件:', hasOutputFile)
    logger.log('🖼️ [API] 是否需要使用FormData:', hasFile)
    
    // 使用 FormData 格式发送数据
    logger.log('📦 [API] 使用 form-data 格式发送')
    const formData = new FormData()
    
    // 添加所有字段到 FormData
    Object.keys(questionData).forEach(key => {
      if (questionData[key] !== null && questionData[key] !== undefined) {
        if (key === 'pictureFile' && questionData[key] instanceof File) {
          // 参考程序结果图片文件
          formData.append('pictureFile', questionData[key])
          logger.log(`📎 [API] 添加文件字段: pictureFile = ${questionData[key].name}`)
        } else if (key === 'outputFile' && questionData[key] instanceof File) {
          // 输出格式图片文件
          formData.append('outputFile', questionData[key])
          logger.log(`📎 [API] 添加文件字段: outputFile = ${questionData[key].name}`)
        } else if (key !== 'pictureFile' && key !== 'outputFile') {
          // 普通字段（跳过已处理的文件字段）
          formData.append(key, String(questionData[key]))
          logger.log(`📝 [API] 添加字段: ${key} = ${questionData[key]}`)
        }
      }
    })
    
    let headers = {
      'Authorization': token || ''
    }
    // FormData 会自动设置 Content-Type，包含正确的 boundary
    // 所以不要手动设置 Content-Type
    
    // 使用fetch调用代理路径，请求方法改为POST
    const response = await fetch(proxyApiUrl, {
      method: 'POST',
      headers: headers,
      body: formData
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    logger.log('✅ [API] 测试题目更新成功')
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 更新测试题目失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack
    })
    throw error
  }
}

/**
 * 删除测试题目
 * @param {string|number} id - 题目ID
 * @returns {Promise} API响应
 */
export const deleteTestQuestion = async (id) => {
  logger.log('🗑️ [API] 删除测试题目...')
  logger.log('🆔 [API] 题目ID:', id)
  logger.log('📊 [API] 请求方法: DELETE')
  
  if (!id) {
    throw new Error('题目ID不能为空')
  }
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/testQuestion/delete'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/testQuestion/delete`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 构建查询参数
    const queryParams = new URLSearchParams()
    queryParams.append('id', String(id))
    
    const finalUrl = `${proxyApiUrl}?${queryParams.toString()}`
    logger.log('🔗 [API] 最终请求URL:', finalUrl)
    
    // 使用fetch调用代理路径
    const response = await fetch(finalUrl, {
      method: 'DELETE',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': token || ''
      }
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    logger.log('✅ [API] 测试题目删除成功')
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 删除测试题目失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack,
      id
    })
    throw error
  }
}

/**
 * 获取别人共享给我的试题
 * @param {Object} params - 查询参数
 * @returns {Promise} API响应
 */
export const getReceivedQuestions = async (params = {}) => {
  logger.log('📨 [API] 获取别人共享给我的试题...')
  logger.log('📝 [API] 查询参数:', params)
  logger.log('📊 [API] 请求方法: GET')
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/course/received'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/course/received`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 获取当前用户ID
    const currentUserId = getCurrentUserIdFromToken()
    logger.log('👤 [API] 当前用户ID:', currentUserId)
    
    // 构建查询参数
    const queryParams = new URLSearchParams()
    
    // 添加分页参数
    queryParams.append('current', String(params.current || 1))
    queryParams.append('size', String(params.size || 10))
    
    // 添加用户ID参数（关键：后端需要知道是哪个用户）
    if (currentUserId) {
      queryParams.append('userId', currentUserId)
      queryParams.append('toUserId', currentUserId)  // 备选参数名
      queryParams.append('receiverId', currentUserId) // 备选参数名
      logger.log('👤 [API] 添加用户筛选条件: userId=' + currentUserId)
    } else {
      logger.warn('⚠️ [API] 无法获取当前用户ID，可能无法获取共享题目')
    }
    
    // 添加搜索参数
    if (params.type) {
      queryParams.append('type', params.type)
    }
    if (params.questionId) {
      queryParams.append('questionId', String(params.questionId))
    }
    if (params.title) {
      queryParams.append('title', params.title)
    }
    
    const finalUrl = `${proxyApiUrl}?${queryParams.toString()}`
    logger.log('🔗 [API] 最终请求URL:', finalUrl)
    
    // 使用fetch调用代理路径
    const response = await fetch(finalUrl, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': token || ''
      }
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    // 检查业务状态码
    if (responseData.code !== 0) {
      logger.error('❌ [API] 业务逻辑错误:', responseData)
      throw new Error(responseData.message || '获取共享题目失败')
    }
    
    logger.log('✅ [API] 别人共享给我的试题获取成功')
    logger.log('📊 [API] 返回题目数量:', responseData?.data?.records?.length || 0)
    logger.log('📊 [API] 总题目数:', responseData?.data?.total || 0)
    
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 获取别人共享给我的试题失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack,
      params
    })
    throw error
  }
}

/**
 * 搜索题目
 * @param {Object} params - 搜索参数
 * @returns {Promise} API响应
 */
export const searchTestQuestions = async (params) => {
  logger.log('🔍 [API] 搜索题目，参数:', params)
  
  try {
    const response = await api.get('/goc/testQuestion/search', {
      params,
      timeout: 15000
    })
    
    logger.log('✅ [API] 题目搜索成功:', response)
    return response
  } catch (error) {
    logger.error('❌ [API] 题目搜索失败:', error)
    throw error
  }
}

/**
 * 共享试题给其他用户
 * @param {Object} shareData - 共享数据
 * @param {string|number} shareData.questionId - 试题ID
 * @param {string|number} shareData.toUserId - 目标用户ID
 * @returns {Promise} API响应
 */
export const shareQuizToUser = async (shareData) => {
  logger.log('📤 [API] 共享试题给其他用户...')
  logger.log('📝 [API] 共享数据:', shareData)
  logger.log('📊 [API] 请求方法: POST')
  logger.log('📦 [API] 请求体内容:')
  console.table(shareData)
  
  if (!shareData.questionId) {
    throw new Error('试题ID不能为空')
  }
  
  if (!shareData.toUserId) {
    throw new Error('目标用户ID不能为空')
  }
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/course/shareQuiz'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/course/shareQuiz`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    if (!token) {
      throw new Error('用户未登录，请先登录后再试')
    }
    
    // 验证令牌格式
    try {
      const tokenParts = token.split('.')
      if (tokenParts.length !== 3) {
        throw new Error('JWT令牌格式异常')
      }
      const payload = JSON.parse(atob(tokenParts[1]))
      logger.log('👤 [API] JWT用户信息:', { id: payload.id, exp: payload.exp })
      
      // 检查令牌是否过期
      if (payload.exp && payload.exp * 1000 < Date.now()) {
        throw new Error('用户登录已过期，请重新登录')
      }
    } catch (jwtError) {
      logger.error('❌ [API] JWT令牌验证失败:', jwtError)
      throw new Error('用户认证信息异常，请重新登录')
    }
    
    // 准备请求数据 - 使用JSON中的原始数字字符串发送，让后端解析为Long
    const questionIdStr = String(shareData.questionId)
    const userIdStr = String(shareData.toUserId)
    
    // 验证数据有效性（检查是否为纯数字字符串）
    if (!/^\d+$/.test(questionIdStr) || !/^\d+$/.test(userIdStr)) {
      throw new Error('试题ID或用户ID格式不正确，必须为数字格式')
    }
    
    // 构建请求数据 - 使用原始JSON字符串替换，避免JavaScript数字精度问题
    const requestDataTemplate = {
      questionId: '__QUESTION_ID__',
      toUserId: '__USER_ID__'
    }
    
    logger.log('📤 [API] 准备数据 - questionId:', questionIdStr, 'toUserId:', userIdStr)
    
    // 创建JSON字符串，然后替换为原始数字（无引号），确保后端接收到Long类型
    let jsonBody = JSON.stringify(requestDataTemplate)
    jsonBody = jsonBody.replace('"__QUESTION_ID__"', questionIdStr)
    jsonBody = jsonBody.replace('"__USER_ID__"', userIdStr)
    
    logger.log('📤 [API] 最终JSON请求体:', jsonBody)
    
    // 使用fetch调用代理路径
    const response = await fetch(proxyApiUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': token || ''
      },
      body: jsonBody
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    // 检查业务状态码
    if (responseData.code !== 0) {
      logger.error('❌ [API] 业务逻辑错误:', responseData)
      throw new Error(responseData.message || '共享失败')
    }
    
    logger.log('✅ [API] 试题共享成功')
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 共享试题失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack,
      shareData
    })
    throw error
  }
}

/**
 * 获取题目的期望代码和测试用例
 * @param {string|number} questionId - 题目ID
 * @returns {Promise} API响应
 */
export const getTestQuestionExpectedData = async (questionId) => {
  logger.log('🔍 [API] 获取题目期望数据，ID:', questionId)
  
  if (!questionId) {
    throw new Error('题目ID不能为空')
  }
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/testQuestion/getExpectedData'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 构建查询参数
    const queryParams = new URLSearchParams()
    queryParams.append('questionId', String(questionId))
    
    const finalUrl = `${proxyApiUrl}?${queryParams.toString()}`
    logger.log('🔗 [API] 最终请求URL:', finalUrl)
    
    // 使用fetch调用代理路径
    const response = await fetch(finalUrl, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': token || ''
      }
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    
    if (!response.ok) {
      throw new Error(`HTTP错误: ${response.status}`)
    }
    
    const responseData = await response.json()
    logger.log('📦 [API] 期望数据响应:', responseData)
    
    return responseData
  } catch (error) {
    logger.error('❌ [API] 获取期望数据失败:', error)
    throw error
  }
}

/**
 * 获取题目的测试代码（答案代码）
 * @param {string|number} questionId - 题目ID
 * @returns {Promise} API响应
 */
export const getTestCode = async (questionId) => {
  logger.log('🔍 [API] 获取题目测试代码（答案），ID:', questionId)
  logger.log('📊 [API] 请求方法: GET')
  
  if (!questionId) {
    throw new Error('题目ID不能为空')
  }
  
  try {
    // 使用代理路径，避免CORS问题
    // 注意：fetch需要手动添加/api前缀来触发代理（开发环境）
    const proxyApiUrl = '/api/goc/testQuestion/getTestCode'
    logger.log('🌐 [API] 代理API地址:', proxyApiUrl)
    logger.log('🌐 [API] 实际目标地址:', `${getBaseURL()}/goc/testQuestion/getTestCode`)
    
    // 获取JWT令牌
    const token = localStorage.getItem('token')
    logger.log('🔑 [API] 使用JWT令牌:', token ? '已获取' : '未找到')
    
    // 构建查询参数
    const queryParams = new URLSearchParams()
    queryParams.append('questionId', String(questionId))
    
    const finalUrl = `${proxyApiUrl}?${queryParams.toString()}`
    logger.log('🔗 [API] 最终请求URL:', finalUrl)
    
    // 使用fetch调用代理路径
    const response = await fetch(finalUrl, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': token || ''
      }
    })
    
    logger.log('📊 [API] 响应状态码:', response.status)
    logger.log('📊 [API] 响应状态文本:', response.statusText)
    
    // 解析响应数据
    const responseData = await response.json()
    logger.log('📦 [API] 响应数据:', responseData)
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
    }
    
    logger.log('✅ [API] 题目测试代码获取成功')
    return { data: responseData, status: response.status }
    
  } catch (error) {
    logger.error('❌ [API] 获取题目测试代码失败:', error)
    logger.error('❌ [API] 错误详情:', {
      message: error.message,
      name: error.name,
      stack: error.stack,
      questionId
    })
    throw error
  }
}

// 默认导出所有API函数
export default {
  createTestQuestion,
  updateTestQuestion,
  deleteTestQuestion,
  getUserCreatedQuestions,
  getTestQuestionList,
  getTestQuestionById,
  getReceivedQuestions,
  searchTestQuestions,
  shareQuizToUser,
  getTestQuestionExpectedData,
  getTestCode
} 